package com.hanxin.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hanxin.mapper.SpecialMapper;
import com.hanxin.pojo.*;
import com.hanxin.service.SpecialService;
import com.hanxin.utils.EditJkf;
import com.hanxin.utils.InformationDto;
import com.hanxin.utils.InsertJkf;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import static com.baomidou.mybatisplus.extension.toolkit.Db.*;

@Service
public class SpecialServiceImpl implements SpecialService {
    @Autowired
    private SpecialMapper specialMapper;

    @Autowired
    private StringRedisTemplate redisTemplate;

    private String hashKey;
    private String hashKey2;
    private String cancel;

    /**
     * 根据传入的对象查询数据
     *
     * @param informationDto
     * @return
     */
    @Override
    public Result<Object> test(InformationDto informationDto) {
        // 分页查询redis的key
        hashKey = "information:" + informationDto.getYear() + ":" + informationDto.getUnit() + ":" +
                informationDto.getAuditstate() + ":" + informationDto.getPointid() + ":" + informationDto.getGrade() + ":" +
                informationDto.getPageNo() + ":" + informationDto.getPageSize();
        // 普通查询redis的key
        hashKey2 = "information:" + informationDto.getYear() + ":" + informationDto.getUnit() + ":" +
                informationDto.getAuditstate() + ":" + informationDto.getPointid() + ":" + informationDto.getGrade();

        // 如果redis中有数据，直接使用redis的数据
        if (redisTemplate.opsForHash().hasKey("information", hashKey) && redisTemplate.opsForHash().hasKey("information", hashKey2)) {
            // 根据key查询redis
            List<TAudit> value = JSON.parseArray((String) redisTemplate.opsForHash().get("information", hashKey), TAudit.class);
            List<TAudit> value2 = JSON.parseArray((String) redisTemplate.opsForHash().get("information", hashKey2), TAudit.class);
            System.out.println("value2-------------" + value2);
            // 查询出的redis长度就是总记录数
            long total = value2.size();
            // 创建result用来将数据返回
            Result<Object> result = new Result<>();
            result.setSuccess(true);
            result.setCode(200);
            result.setResult(value);
            result.setResult2(value2);
            // 设置总记录数
            result.setTotal(total);
            // 返回结果
            return result;
        } else {
            // 分页查询     分页的页数，每页显示的数据量
            Page<TAudit> page = new Page<>(informationDto.getPageNo(), informationDto.getPageSize());
            System.out.println("---------------------" + informationDto.getPageNo() + informationDto.getPageSize());
            // 根据条件进行分页查询
            IPage<TAudit> pageInfo = specialMapper.getByInformation(page, informationDto.getYear(),
                    informationDto.getUnit(), informationDto.getAuditstate(), informationDto.getPointid(),
                    informationDto.getGrade());
            System.out.println("page--------------------------" + pageInfo.getTotal());
            // 查询结果存放到List<TAudit>集合中
            List<TAudit> value = pageInfo.getRecords();
            // 根据普通条件查询，为了获取总记录数
            List<TAudit> totalNum = specialMapper.getByInformation1(informationDto.getYear(),
                    informationDto.getUnit(), informationDto.getAuditstate(), informationDto.getPointid(),
                    informationDto.getGrade());
            // 查询到的结果长度为总记录数
            int totalInformation = totalNum.size();
            // 转换为json
            String jsonTotalNum = JSON.toJSONString(totalNum);
            // 将普通查询的数据写入redis
            redisTemplate.opsForHash().put("information", hashKey2, jsonTotalNum);
            // 设置redis过期时间为30分钟
            redisTemplate.expire("information", 30, TimeUnit.MINUTES);

            long total = page.getTotal(); // 总记录数
            long pages = page.getPages(); // 总页数
            long current = page.getCurrent(); // 当前页码
            long size = page.getSize(); // 每页显示数量

            // 打印查询结果以及分页信息
            System.out.println("查询结果：" + value);
            System.out.println("总记录数：" + total);
            System.out.println("总页数：" + pages);
            System.out.println("当前页码：" + current);
            System.out.println("每页显示数量：" + size);
            System.out.println("查询总页数：" + totalInformation);

            // 将分页查询的数据转换为json
            String jsonValue = JSON.toJSONString(value);
            System.out.println("jsonValue----------------------------------------------------" + jsonValue);
            // 将分页查询的数据存入redis
            redisTemplate.opsForHash().put("information", hashKey, jsonValue);
            // 设置redis过期时间为30分钟
            redisTemplate.expire("information", 30, TimeUnit.MINUTES);

            // 创建result用于存放返回信息
            Result<Object> result = new Result<>();
            result.setSuccess(true);
            result.setCode(200);
            // 将分页查询的数据存入result
            result.setResult(value);
            result.setResult2(totalNum);
            // 设置总记录数
            result.setTotal(totalInformation);
            // 返回数据
            return result;
        }
    }

    /**
     * 根据id集合删除数据
     *
     * @param ids
     * @return
     */
    @Override
    public Result<Object> deleteByIds(List<Integer> ids) {
        // 删除key
        redisTemplate.opsForHash().delete("information", hashKey);
        redisTemplate.opsForHash().delete("information", hashKey2);
        // 根据id集合批量删除数据
        int ids1 = specialMapper.deleteBatchIds(ids);
        // 判断删除的数据量与传入的数据量是否一致
        if (ids1 == ids.size()) {
            try {
                // 线程休眠
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Result.error("休眠中");
            }
            // 删除key
            redisTemplate.opsForHash().delete("information", hashKey);
            redisTemplate.opsForHash().delete("information", hashKey2);
            return Result.ok("删除成功");
        }
        return Result.error("删除失败");
    }

    /**
     * 根据id集合修改审核状态为“待审核”
     *
     * @param ids
     * @return
     */
    @Override
    public Result<Object> updateByids(List<Integer> ids) {
        // 创建Mybatisplus的UpdateWrapper集合对象
        UpdateWrapper<TAudit> updateWrapper = new UpdateWrapper<>();
        // 获取到id集合
        updateWrapper.in("id", ids);
        // 创建数据实体类
        TAudit updateEntity = new TAudit();
        // 设置要更新的字段和值
        updateEntity.setAuditstate("待审核");

        // 删除缓存
        redisTemplate.delete("information");

        // 使用mybatispl批量修改数据库
        int updated = specialMapper.update(updateEntity, updateWrapper);
        // 判断修改量与传入的id集合数量是否一致
        if (updated == ids.size()) {
            try {
                // 线程休眠
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Result.error("休眠中");
            }
            // 删除缓存
            redisTemplate.delete("information");
            return Result.ok("更改成功");
        }
        return Result.ok("更改失败");
    }

   /**
     * 根据id集合修改申请状态为”已保存“
     *
     * @param ids
     * @return
     */
    @Override
    public Result<Object> updatezByids(List<Integer> ids) {
        // 创建Mybatisplus的UpdateWrapper集合对象
        UpdateWrapper<TAudit> updateWrapper = new UpdateWrapper<>();
        // 获取到id集合
        updateWrapper.in("id", ids);
        // 创建数据实体类
        TAudit updateEntity = new TAudit();
        // 设置要更新的字段和值
        updateEntity.setAuditstate("已保存");

        // 删除缓存
        redisTemplate.delete("information");

        // 使用mybatispl批量修改数据库
        int updated = specialMapper.update(updateEntity, updateWrapper);
        // 判断修改量与传入的id集合数量是否一致
        if (updated == ids.size()) {
            try {
                // 线程休眠
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Result.error("休眠中");
            }
            // 删除缓存
            redisTemplate.delete("information");
            return Result.ok("更改成功");
        }
        return Result.ok("更改失败");
    }

    /**
     * 根据传入的参数新增特殊加扣分
     *
     * @param insertJkf
     * @return
     */
    @Override
    public Result<Object> insertJkf(InsertJkf insertJkf) {
        // 判断是否是当前年份
        LocalDate currentDate = LocalDate.now();
        if (insertJkf.getYear() != currentDate.getYear()) {
            return Result.error("年份错误");
        } else {
            // 创建实体类对象
            TAudit tAudit = new TAudit();
            tAudit.setYear(insertJkf.getYear());
            tAudit.setUnit(insertJkf.getUnit());
            tAudit.setPointid(insertJkf.getPointid());
            tAudit.setGrade(insertJkf.getGrade());
            tAudit.setApplynum(insertJkf.getApplynum());
            tAudit.setRequestcause(insertJkf.getRequestcause());

            // 删除redis缓存
            redisTemplate.delete("information");
            // 执行新增语句
            boolean inserted = save(tAudit);
            // 判断是否新增成功
            if (inserted) {
                // 线程休眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 删除缓存
                redisTemplate.delete("information");
                return Result.ok("新增成功");
            }
        }
        return Result.error("执行错误");
    }

    /**
     * 根据传入的参数查询特殊加扣分信息
     * @param editId
     * @return
     */
    @Override                                                  
    public Result<Object> editGetJkf(EditJkf editId)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
        // 分页查询redis的key
        cancel = "cancelJkf:" + editId.getYear() + ":" + editId.getUnit() + ":" +
                editId.getPointid() + ":" + editId.getGrade();
        if (redisTemplate.opsForHash().hasKey("cancelJkf", cancel) && redisTemplate.opsForHash()
                .hasKey("cancelJkf", cancel)){
           return Result.ok(JSON.parseArray((String) redisTemplate.opsForHash().get("cancelJkf", cancel),
                   TAudit.class));
        }

        return Result.error("当前没有缓存");
    }
    /**                               
     * 根据传入的参数设置缓存
     * @param editJkf
     * @return
     */
    @Override
    public Result<Object> cancelJkf(EditJkf editJkf) {
        // 分页查询redis的key
        cancel = "cancelJkf:" + editJkf.getYear() + ":" + editJkf.getUnit() + ":" +
                editJkf.getPointid() + ":" + editJkf.getGrade();

        // 将 editJkf 对象转换为 JSON 字符串
        String jsonString = JSON.toJSONString(editJkf);
        redisTemplate.opsForHash().put("cancelJkf",cancel,jsonString);
        redisTemplate.expire("cancelJkf",30,TimeUnit.MINUTES);
        return Result.error("缓存成功");
    }


    /**
     * 根据传入的参数将数据从数据库查出返回到编辑页面
     * @param editJkf
     * @return
     */
    @Override
    public Result<Object> editCheckJkf(EditJkf editJkf) {
        // 查询原数据
        TAudit originalData = specialMapper.selectById(editJkf.getId());
        // 判断当前数据是否存在
        if (originalData == null) {
            return Result.error("数据不存在");
        }
        return Result.ok(originalData);
    }


    /**
     * 根据传入的id编辑特殊加扣分信息
     * @param editJkf
     * @return
     */
    @Override
    public Result<Object> editJkf(EditJkf editJkf) {
        // 查询原数据
        TAudit originalData = specialMapper.selectById(editJkf.getId());
        // 判断当前数据是否存在
        if (originalData == null) {
            return Result.error("数据不存在");
        }
        // 判断是否是当前年份
        LocalDate currentDate = LocalDate.now();
        if (editJkf.getYear() != currentDate.getYear()) {
            return Result.error("年份错误");
        } else {
            // 创建实体类对象
            TAudit tAudit = new TAudit();
            tAudit.setId(editJkf.getId());
            tAudit.setYear(editJkf.getYear());
            tAudit.setUnit(editJkf.getUnit());
            tAudit.setApplynum(editJkf.getApplynum());
            tAudit.setRequestcause(editJkf.getRequestcause());

            // 删除redis缓存
            redisTemplate.delete("information");
            System.out.println("id-------------------"+editJkf.getId());
            // 执行编辑语句
            int inserted = specialMapper.updateById(tAudit);
            // 判断是否编辑成功
            if (inserted>0) {
                // 线程休眠
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 删除缓存
                redisTemplate.delete("information");
                return Result.ok("新增成功");
            }
        }
        return Result.error("执行错误");
    }


}
